"use strict";
const mvc = require('cosjs.mvc');
const debug = mvc.library.require('debug');
const random = mvc.library.require('random');
/**
 * @name chipAttr
 * 芯片养成
 */

/**
 * @name levelUp
 * @param string key 芯片唯一ID
 * @param int lv 增加等级
 * 升级（强化）
 */
exports.levelUp = async function () {
    let key = this.get('key', 'string');
    if (!key) {
        return this.quick_error("M2saghge10", "参数缺失key");
    }
    let lv = this.get('lv', 'int');
    if (!lv) {
        return this.quick_error("M2saghge10", "参数缺失key");
    }
    this.updater.item.key(key);
    await this.updater.data();
    let equip = this.updater.item.get(key);
    if (!equip) {
        return this.quick_error("M2saghge20", "装备不存在", key);
    }
    let equipConfig = this.config('chip', equip.id);
    if (!equipConfig) {
        return this.quick_error("M2saghge40", "装备数据不存在", equip.id);
    }
    //先区分芯片类型
    if(equipConfig.chipKind != 1){
        return this.quick_error("M2saghge40", "芯片类型错误", equip.id);
    }
    //统计对应的黄星消耗
    // let costYellowNum =0;
    let addExp = 0;
    let totalExp = equip.exp+addExp
    let useExpNum = 0;
    let subData = {};
    for(let i=0;i<lv;i++){  
        let configId = equipConfig.chipKind* 10000+equipConfig.rareKey* 1000 + equip.lv;
        let expConfig = this.config('chipLv', configId);
        if (!expConfig) {
            return this.quick_error("M2saghge50", "消耗配置不存在", configId);
        }
        //材料消耗
        let flag = false;
        for (let d of expConfig["sub"]) {
            if(!d.id){
                continue;
            }
            flag = true;
                if(subData[d.id]){
                    subData[d.id] += d.num;
                }else{
                    subData[d.id] = d.num;
                }
        }
        if(!flag){
            return this.quick_error("M2saghge60", "消耗配置不存在", configId);
        }
        equip.lv++;
        let recordConfig = this.config("record","40"+equip.lv)
        if(recordConfig){
            this.updater.record.add("40"+equip.lv,1);
        }               
        let addBaseTime = this.config("base","chipAdvance").val;
        if(equip.lv%addBaseTime == 0){
            //额外逻辑
            //判断副属性是否已经全满
            let attrNum = 0;
            for(let key in equip.otherAttr){
                attrNum++;
            }
            //增加副属性值，从现有的属性里随机一个升级lv
            let attrList = [];
            for(let id in equip.otherAttr){
                attrList.push(id);
            }
            let k = random.Relative(attrList, 'weight');
            if (k === false) {
                return this.quick_error("M7GHLB123", 'err request', k);
            }
            let attrID = attrList[k];
            equip.otherAttr[attrID].lv++;
        }
        // costYellowNum += expConfig.requireStar;
        totalExp -= expConfig.requireExp
        useExpNum+=expConfig.requireExp;
    
        // this.updater.sub(60100002, costYellowNum);
       
    }
    for(let key in subData){
        this.updater.sub(parseInt(key), subData[key]);
    }
    this.updater.item.set(equip._id, equip);
    this.updater.record.add(15,1);
    this.updater.daily.add("record."+"15",1);
    this.updater.record.add(39,1);
    return this.updater.save()
}


/**
 * @name extraLevelUp
 * @param string key 芯片唯一ID
 * @param int id 芯片属性ID
 * 特殊芯片升级（强化）
 */
exports.extraLevelUp = async function () {
    let key = this.get('key', 'string');
    if (!key) {
        return this.quick_error("M2saghge10", "参数缺失key");
    }
    let id = this.get('id', 'string');
    this.updater.item.key(key);
    await this.updater.data();
    let equip = this.updater.item.get(key);
    if (!equip) {
        return this.quick_error("M2saghge20", "装备不存在", key);
    }
    let equipConfig = this.config('chip', equip.id);
    if (!equipConfig) {
        return this.quick_error("M2saghge40", "装备数据不存在", equip.id);
    }
    //先区分芯片类型
    if(equipConfig.chipKind != 2){
        return this.quick_error("M2saghge40", "芯片类型错误", equip.id);
    }
    //判断extraAttr里是否有id属性
    if(!equip.extraAttr[id]){
        return this.quick_error("M2saghge40", "本词条不存在", equip.id);
    }
    // 判断extraAttr里的Data数组长度是否已经达到最大值 写死10
    if(equip.extraAttr[id].Data.length >=10){
        return this.quick_error("M2saghge40", "本词条已经强化完毕", equip.id);
    }
    //计算本次强化成功率
    let baseRate = this.config('base', 'beginSpchipAdvance').val;
    const changeRate = this.config('base', 'spchipAdvance').val;
    //遍历equip.extraAttr
    for(let k in equip.extraAttr){
        if(k == 'count'){
            //老旧兼容代码，后期优化掉
            continue;
        }
        for(let i=0;i<equip.extraAttr[k].Data.length;i++){
            if(equip.extraAttr[k].Data[i]){
                baseRate-=changeRate;
            }else{
                baseRate+=changeRate;
            }
        }
    }
   
    //判断本次强化是否成功
    if(Math.roll(0,100)<baseRate){
        equip.extraAttr[id].Data.push(1);
    }else{
        equip.extraAttr[id].Data.push(0);
        // equip.extraAttr.count++;
    }
    equip.lv++;
    //计算数值变化（初始值确定后不需要我这算了）
    //计算消耗材料
    let configId = equipConfig.chipKind * 10000+equipConfig.rareKey * 1000;
    let sConfig = this.config('chipLv',configId);
    if (!sConfig) {
        return this.quick_error("M2saghge200", "材料装备配置不存在", configId);
    }
    for(let i=0;i<sConfig.sub.length;i++){
        this.updater.sub(sConfig.sub[i].id,sConfig.sub[i].num);
    }
    this.updater.item.set(equip._id, equip);
    return this.updater.save();
}


// function randAttr(groupID){
//     let config = mvc.config('chipAttr',groupID);
//     if(!config){
//         return debug('config not exist','chip',groupID);
//     }
    
//     let attrID = 0;
//     let attrValue = 0;
//     let addSorce = 0;
//     for(let value in  config.attr){
//         addSorce+=config.attr[value].weight
//     }
//     let randNum = Math.roll(0, addSorce);
//     for(let value in  config.attr){
//         randNum+=config.attr[value].weight
//         if(randNum >= addSorce){
//             // console.log("value:",value);
//             attrID = config.attr[value].id;
//             let attrList = config.attr[value].value.split(',');
//             let attrconfig = mvc.config('chipBuff',attrID);
//             // attrValue = Math.roll(parseFloat(attrList[0]),parseFloat(attrList[1]));
//             if(!attrconfig){
//                 return debug('config not exist','chipBuff',attrID);
//             }
//             attrList[0] = (parseFloat(attrList[0])*1/attrconfig.attrAccuracy)
//             attrList[1] = (parseFloat(attrList[1])*1/attrconfig.attrAccuracy)
//             attrValue = Math.roll(attrList[0],attrList[1]);
//             // if(attrValue == 0){
//             //     console.log("1",attrList[0],attrList[1]);
//             // }
//             attrValue = parseFloat(attrValue-attrconfig.attrAccuracy);
//             // if(attrValue == 0){
//             //     console.log("2:",attrValue-attrconfig.attrAccuracy);
//             // }
//             break;
//         }
//         //随机操作
//     }
//     var obj = new Object();
//         obj.ID = attrID;
//         obj.Value = attrValue;
//     return   obj;
// }

/**
 * @name setChip
 * @param string unitKey 单位唯一ID
 * @param string chipKey 芯片唯一ID ,如果为空代表卸下对应芯片
 * @param string site 安装位置
 * 安装芯片
 */
 exports.setChip = async function () {
    let unitKey = this.get('unitKey', 'string');
    let chipKey = this.get('chipKey', 'string');
    let site = this.get('site', 'string');
    if (!unitKey||!site) {
        return this.quick_error("M2saghge10", "参数缺失key");
    }
    this.updater.item.key(unitKey);
    this.updater.item.key(chipKey);
    await this.updater.data();
    let unit = this.updater.item.get(unitKey);
    if (!unit) {
        return this.quick_error("M2saghge20", "单位不存在", unitKey);
    }
    if (chipKey!='') {
        let chip = this.updater.item.get(chipKey);
        if (!chip) {
            return this.quick_error("M2saghge20", "芯片不存在", chipKey);
        }
        if(unit.chipList[site]){
            if(unit.chipList[site] == chipKey){
                return this.quick_error("M2saghge20", "不能重复安装", unit.chipList[site]);
            }
            this.updater.item.key(unit.chipList[site]);
            await this.updater.data();
            let oldChip = this.updater.item.get(unit.chipList[site]);
            if (!oldChip) {
                return this.quick_error("M2saghge20", "芯片不存在", unit.chipList[site]);
            }
            oldChip.use = '';
            this.updater.item.set(oldChip._id, oldChip);
            // return this.quick_error("M2saghge20", "位置已经存在其他芯片", unitKey);
        }
        if(chip.use!=''){
            this.updater.item.key(chip.use);
            await this.updater.data();
            let oldUnit = this.updater.item.get(chip.use);
            if (!oldUnit) {
                return this.quick_error("M2saghge20", "单位不存在", chip.use);
            }
            for (let s in oldUnit.chipList){
                if(oldUnit.chipList[s] == chip._id){
                    delete oldUnit.chipList[s];
                    this.updater.item.set(oldUnit._id, oldUnit);
                    break;
                }
            }
            // return this.quick_error("M2saghge20", "芯片已被安装", chipKey);
        }
        chip.use = unitKey;
        unit.chipList[site] = chip._id;
        this.updater.item.set(chip._id, chip);
    }else{
        this.updater.item.key(unit.chipList[site]);
        await this.updater.data();
        let chip = this.updater.item.get(unit.chipList[site]);
        if (!chip) {
            return this.quick_error("M2saghge20", "芯片不存在", chipKey);
        }
        chip.use = '';
        delete  unit.chipList[site];
        // unit.chipList[site] = ''; 
        this.updater.item.set(chip._id, chip);
    }
    this.updater.item.set(unit._id,"chipList", unit.chipList);
    return this.updater.save();
}




/**
 * @name setAllChip
 * @param string unitKey 单位唯一ID
 * @param json chipList 安装内容
 * 一键安装芯片
 */
exports.setAllChip = async function () {
    let unitKey = this.get('unitKey', 'string');
    let chipList = this.get('chipList', 'json');
    if (!unitKey||!chipList) {
        return this.quick_error("M2saghge10", "参数缺失key");
    }
    this.updater.item.key(unitKey);
    for(let k in chipList) {
        this.updater.item.key(chipList[k]);
    }
    await this.updater.data();
    let unit = this.updater.item.get(unitKey);
    if (!unit) {
        return this.quick_error("M2saghge20", "单位不存在", unitKey);
    }
    for(let site in chipList) {
        var chipKey = chipList[site];
        if (chipKey!='') {
            let chip = this.updater.item.get(chipKey);
            if (!chip) {
                return this.quick_error("M2saghge20", "芯片不存在", chipKey);
            }
            if(unit.chipList[site]){
                // if(unit.chipList[site] == chipKey){
                //     return this.quick_error("M2saghge20", "不能重复安装", unit.chipList[site]);
                // }
                this.updater.item.key(unit.chipList[site]);
                await this.updater.data();
                let oldChip = this.updater.item.get(unit.chipList[site]);
                if (!oldChip) {
                    return this.quick_error("M2saghge20", "芯片不存在", unit.chipList[site]);
                }
                oldChip.use = '';
                this.updater.item.set(oldChip._id, oldChip);
            }
            if(chip.use!=''){
                this.updater.item.key(chip.use);
                await this.updater.data();
                let oldUnit = this.updater.item.get(chip.use);
                if (!oldUnit) {
                    return this.quick_error("M2saghge20", "单位不存在", chip.use);
                }
                for (let s in oldUnit.chipList){
                    if(oldUnit.chipList[s] == chip._id){
                        delete oldUnit.chipList[s];
                        this.updater.item.set(oldUnit._id, oldUnit);
                        break;
                    }
                }
            }
            chip.use = unitKey;
            unit.chipList[site] = chip._id;
            this.updater.item.set(chip._id, chip);
        }else{
            this.updater.item.key(unit.chipList[site]);
            await this.updater.data();
            let chip = this.updater.item.get(unit.chipList[site]);
            if (!chip) {
                return this.quick_error("M2saghge20", "芯片不存在", chipKey);
            }
            chip.use = '';
            delete  unit.chipList[site];
            this.updater.item.set(chip._id, chip);
        }
    }
    this.updater.item.set(unit._id,"chipList", unit.chipList);
    return this.updater.save();
}




/**
 * @name unsetAllChip
 * @param string unitKey 单位唯一ID
 * 一键卸载芯片
 */
 exports.unsetAllChip = async function () {
    let unitKey = this.get('unitKey', 'string');
    if (!unitKey) {
        return this.quick_error("M2saghge10", "参数缺失key");
    }
    this.updater.item.key(unitKey);
    await this.updater.data();
    let unit = this.updater.item.get(unitKey);
    if (!unit) {
        return this.quick_error("M2saghge20", "单位不存在", unitKey);
    }
    for (let s in unit.chipList){
        this.updater.item.key(unit.chipList[s]);
    }
    await this.updater.data();
    for (let s in unit.chipList){
        this.updater.item.key(unit.chipList[s]);
        let Chip = this.updater.item.get(unit.chipList[s]);
            if (!Chip) {
                return this.quick_error("M2saghge20", "芯片不存在", unit.chipList[s]);
            }
            Chip.use = '';
            this.updater.item.set(Chip._id, Chip);
            delete  unit.chipList[s];
    }
    this.updater.item.set(unit._id,"chipList", unit.chipList);
    return this.updater.save();
}



/**
 * @name refine
 * @param string sub 芯片ID串,以","分割
 * 分解
 */
 exports.refine = async function () {
    //TODO：上锁逻辑需要补全
    const sub = this.get('sub', 'string').trim();
    if (!sub) {
        return this.quick_error('M2saghge140', '必须有消耗品');
    }
    let arrSub = sub.split(",");
    for (let s of arrSub) {
        if (!s) {
            return this.quick_error('M2saghge150', '消耗品不能为空');
        }
        this.updater.item.key(s);
    }
    // this.updater.item.key(key);
    await this.updater.data();

    // this.updater.item.key()

    // let equip = this.updater.item.get(key);
    // if (!equip) {
    //     return this.quick_error("M2saghge160", "装备不存在", key);
    // }
    // if (rlv != equip.rlv + 1) {
    //     return this.quick_error("M2saghge170", "目标精炼等级不匹配", equip.rlv + 1, rlv,);
    // }
    // let equipConfig = this.config('equip', equip.id);
    // let configId = equipConfig.refine * 1000 + rlv;
    // let refineConfig = this.config('equipRefine', configId);
    // if (!refineConfig) {
    //     return this.quick_error("M2saghge171", "配置不存在", configId);
    // }

    // if (arrSub.length != refineConfig.equipNum) {
    //     return this.quick_error("M2saghge180", "消耗数量不对", arrSub.length, refineConfig.equipNum);
    // }

    let set = {}
    let useList = {};
    for (let s of arrSub) {
        let ss = this.updater.item.get(s);
        if (!ss) {
            return this.quick_error('M2saghge190', '消耗的装备不存在', s);
        }
        if (set[s]) {
            return this.quick_error('M2saghge191', '有重复的材料', s);
        }
        if(ss.use!=""){
            useList[ss._id] = ss.use;
            this.updater.item.key(ss.use);
        }
        set[s] = 1;
        // let lineupSet = this.updater.role.get('lineupSet');
        // for (let i = 1; i < LINEUP_MAX; ++i) {
        //     if (lineupSet) {
        //         let lineset = lineupSet[i];
        //         if (lineset) {
        //             for (let j = 0; j < POS_MAX; ++j) {
        //                 if (lineset.equipColl[j] == s) {
        //                     return this.quick_error('M2saghge102', '在编组的装备无法被消耗', s);
        //                 }
        //             }
        //         }
        //     }
        // }
        let chipConfig = this.config('chip', ss.id);
        if(!chipConfig){
            return this.quick_error("M2saghge171", "配置不存在", ss.id);
        }
        let configId = chipConfig.chipKind * 10000+chipConfig.rareKey * 1000 + ss.lv;
        let sConfig = this.config('chipLv',configId);
        if (!sConfig) {
            return this.quick_error("M2saghge200", "材料装备配置不存在", configId);
        }
        // if (sConfig.qlv != refineConfig.equipQlv) {
        //     return this.quick_error("M2saghge210", "消耗装备的品质不符", refineConfig.equipQlv, sConfig.qlv);
        // }
        for(let k in sConfig.resolve){
            if(sConfig.resolve[k].num){
                // this.updater.item.add(sConfig.resolve[k].id);
                this.updater.item.add(sConfig.resolve[k].id,sConfig.resolve[k].num);
            }
        }
       
        // let {err, ret} = this.updater.item.group(sConfig.resolveId);
        // if (err) {
        //     return this.error(err, ret);
        // }
        //退回强化材料
        // let equipExpConfigId = sConfig.pos * 1000 + ss.lv;
        // let lvReturnConfig = this.config('equipExp', equipExpConfigId);
        // if (lvReturnConfig) {
        //     for (let rr of lvReturnConfig.returnCost) {
        //         if (rr.id && rr.num) {
        //             this.updater.add(rr.id, rr.num);
        //         }
        //     }
        // }

        // //退回精炼材料
        // let equipRefineConfigId = sConfig.refine * 1000 + ss.rlv;
        // let equipRefineConfig = this.config('equipRefine', equipRefineConfigId);
        // if (equipRefineConfig) {
        //     for (let rr of equipRefineConfig.returnCost) {
        //         if (rr.id && rr.num) {
        //             this.updater.add(rr.id, rr.num);
        //         }
        //     }
        // }
        this.updater.item.del(s);
    }
    await this.updater.data();
    let unitAlldata = {};
    for(let chipID in useList){
        if(!unitAlldata[useList[chipID]]){
            let unitData = this.updater.item.get(useList[chipID]);
            unitAlldata[useList[chipID]] = unitData;
        }
        let unitData = unitAlldata[useList[chipID]];
        for(let key in unitData.chipList){
            if(unitData.chipList[key] == chipID){
                delete  unitData.chipList[key];
                //this.updater.item.set(unitID,"chipList",unitData.chipList);
            }
        }
    }
    for(let unitID in unitAlldata){
        this.updater.item.set(unitID,"chipList",unitAlldata[unitID].chipList);
    }
    // equip.rlv++;
    // this.updater.item.set(equip._id, equip);
    // this.updater.record.add(2300, 1);
    return this.updater.save();

}



// /**
//  * @name lock
//  * @param string sub 芯片ID串,以","分割
//  * 上锁
//  */
//  exports.lock = async function () {
//     const sub = this.get('sub', 'string').trim();
//     if (!sub) {
//         return this.quick_error('M2saghge140', '必须有消耗品');
//     }
//     let arrSub = sub.split(",");
//     for (let s of arrSub) {
//         if (!s) {
//             return this.quick_error('M2saghge150', '消耗品不能为空');
//         }
//         this.updater.item.key(s);
//     }
//     // this.updater.item.key(key);
//     await this.updater.data();

//     let set = {}
//     for (let s of arrSub) {
//         let ss = this.updater.item.get(s);
//         if (!ss) {
//             return this.quick_error('M2saghge190', '消耗的装备不存在', s);
//         }
//         if (set[s]) {
//             return this.quick_error('M2saghge191', '有重复的材料', s);
//         }
//         set[s] = 1;
//         // let configId = ss.rareKey * 1000 + ss.lv;
//         // let sConfig = this.config('chipLv',configId);
//         // if (!sConfig) {
//         //     return this.quick_error("M2saghge200", "材料装备配置不存在", s);
//         // }
//         if(ss.isLocked == true) {
//             ss.isLocked = false;
//             this.updater.item.set(ss._id,ss);
//         }else{
//             ss.isLocked = true;
//             this.updater.item.set(ss._id,ss);
//             // this.updater.item.set(ss._id,"isLocked",true);
//         }
       
//     }
//     // this.updater.record.max(1000,1);
//     // this.updater.record.max(20001,1);
//     // this.updater.collect.add(1117,2224,335);
//     // this.updater.collect.update('1xox2-1112');
//     // this.updater.collect.set(1112,2224,335);
//     // this.updater.collect.set(1115,2225,335);
//     // this.updater.collect.set(1114,2224,335);
//     this.updater.daily.set('lockchip',1);
//    return this.updater.save();
//     // return 1;
// }


// /**
//  * @name unlock
//  * @param string sub 芯片ID串,以","分割
//  * 解锁
//  */
//  exports.unlock = async function () {
//     const sub = this.get('sub', 'string').trim();
//     if (!sub) {
//         return this.quick_error('M2saghge140', '必须有消耗品');
//     }
//     let arrSub = sub.split(",");
//     for (let s of arrSub) {
//         if (!s) {
//             return this.quick_error('M2saghge150', '消耗品不能为空');
//         }
//         this.updater.item.key(s);
//     }
//     // this.updater.item.key(key);
//     await this.updater.data();

//     let set = {}
//     for (let s of arrSub) {
//         let ss = this.updater.item.get(s);
//         if (!ss) {
//             return this.quick_error('M2saghge190', '消耗的装备不存在', s);
//         }
//         if (set[s]) {
//             return this.quick_error('M2saghge191', '有重复的材料', s);
//         }
//         set[s] = 1;
//         // let configId = ss.rareKey * 1000 + ss.lv;
//         // let sConfig = this.config('chipLv',configId);
//         // if (!sConfig) {
//         //     return this.quick_error("M2saghge200", "材料装备配置不存在", s);
//         // }
//         this.updater.item.set(ss._id,"isLocked",false);
//     }

//    return this.updater.save();
// }